home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / site-packages / Numeric / Matrix.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-03-29  |  7.2 KB  |  268 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import string
  5. import types
  6. import Numeric
  7. import LinearAlgebra
  8. from UserArray import UserArray, asarray
  9. from Numeric import dot, identity, multiply
  10. from MLab import squeeze
  11. _table = [
  12.     None] * 256
  13. for k in range(256):
  14.     _table[k] = chr(k)
  15.  
  16. _table = ''.join(_table)
  17. _numchars = string.digits + '.-+jeEL'
  18. _todelete = []
  19. for k in _table:
  20.     if k not in _numchars:
  21.         _todelete.append(k)
  22.         continue
  23.  
  24. _todelete = ''.join(_todelete)
  25.  
  26. def _eval(astr):
  27.     return eval(astr.translate(_table, _todelete))
  28.  
  29.  
  30. def _convert_from_string(data):
  31.     data.find
  32.     rows = data.split(';')
  33.     newdata = []
  34.     count = 0
  35.     for row in rows:
  36.         trow = row.split(',')
  37.         newrow = []
  38.         for col in trow:
  39.             temp = col.split()
  40.             newrow.extend(map(_eval, temp))
  41.         
  42.         if count == 0:
  43.             Ncols = len(newrow)
  44.         elif len(newrow) != Ncols:
  45.             raise ValueError, 'Rows not the same size.'
  46.         
  47.         count += 1
  48.         newdata.append(newrow)
  49.     
  50.     return newdata
  51.  
  52. _lkup = {
  53.     '0': '000',
  54.     '1': '001',
  55.     '2': '010',
  56.     '3': '011',
  57.     '4': '100',
  58.     '5': '101',
  59.     '6': '110',
  60.     '7': '111' }
  61.  
  62. def _binary(num):
  63.     ostr = oct(num)
  64.     bin = ''
  65.     for ch in ostr[1:]:
  66.         bin += _lkup[ch]
  67.     
  68.     ind = 0
  69.     while bin[ind] == '0':
  70.         ind += 1
  71.     return bin[ind:]
  72.  
  73.  
  74. class Matrix(UserArray):
  75.     
  76.     def __init__(self, data, typecode = None, copy = 1, savespace = 0):
  77.         if type(data) is types.StringType:
  78.             data = _convert_from_string(data)
  79.         
  80.         UserArray.__init__(self, data, typecode, copy, savespace)
  81.         if len(self.array.shape) == 1:
  82.             self.array.shape = (1, self.array.shape[0])
  83.         
  84.         self.shape = self.array.shape
  85.  
  86.     
  87.     def __getitem__(self, index):
  88.         out = self._rc(self.array[index])
  89.         
  90.         try:
  91.             n = len(index)
  92.             if n > 1 and isinstance(index[0], types.SliceType) and isinstance(index[1], types.IntType):
  93.                 sh = out.array.shape
  94.                 out.array.shape = (sh[1], sh[0])
  95.                 out.shape = out.array.shape
  96.         except TypeError:
  97.             pass
  98.  
  99.         return out
  100.  
  101.     
  102.     def __mul__(self, other):
  103.         aother = asarray(other)
  104.         if len(aother.shape) == 0:
  105.             return self._rc(self.array * aother)
  106.         else:
  107.             return self._rc(dot(self.array, aother))
  108.  
  109.     
  110.     def __rmul__(self, other):
  111.         aother = asarray(other)
  112.         if len(aother.shape) == 0:
  113.             return self._rc(aother * self.array)
  114.         else:
  115.             return self._rc(dot(aother, self.array))
  116.  
  117.     
  118.     def __imul__(self, other):
  119.         aother = asarray(other)
  120.         self.array = dot(self.array, aother)
  121.         return self
  122.  
  123.     
  124.     def __pow__(self, other):
  125.         shape = self.array.shape
  126.         if len(shape) != 2 or shape[0] != shape[1]:
  127.             raise TypeError, 'matrix is not square'
  128.         
  129.         if type(other) in (type(1), type(0x1L)):
  130.             if other == 0:
  131.                 return Matrix(identity(shape[0]))
  132.             
  133.             if other < 0:
  134.                 result = Matrix(LinearAlgebra.inverse(self.array))
  135.                 x = Matrix(result)
  136.                 other = -other
  137.             else:
  138.                 result = self
  139.                 x = result
  140.             if other <= 3:
  141.                 while other > 1:
  142.                     result = result * x
  143.                     other = other - 1
  144.                 return result
  145.             
  146.             beta = _binary(other)
  147.             t = len(beta)
  148.             Z = x.copy()
  149.             q = 0
  150.             while beta[t - q - 1] == '0':
  151.                 Z *= Z
  152.                 q += 1
  153.             result = Z.copy()
  154.             for k in range(q + 1, t):
  155.                 Z *= Z
  156.                 if beta[t - k - 1] == '1':
  157.                     result *= Z
  158.                     continue
  159.             
  160.             return result
  161.         else:
  162.             raise TypeError, 'exponent must be an integer'
  163.  
  164.     
  165.     def __rpow__(self, other):
  166.         raise TypeError, 'x**y not implemented for matrices y'
  167.  
  168.     
  169.     def __invert__(self):
  170.         return Matrix(Numeric.conjugate(self.array))
  171.  
  172.     
  173.     def __setattr__(self, attr, value):
  174.         if attr == 'shape':
  175.             if len(value) == 0:
  176.                 value = (1, 1)
  177.             
  178.             if len(value) == 1:
  179.                 value = (1,) + value
  180.             
  181.             if len(value) != 2:
  182.                 raise ValueError, 'Can only reshape a Matrix as a 2-d array.'
  183.             
  184.             self.array.shape = value
  185.         
  186.         self.__dict__[attr] = value
  187.  
  188.     
  189.     def __getattr__(self, attr):
  190.         if attr == 'A':
  191.             return squeeze(self.array)
  192.         elif attr == 'T':
  193.             return Matrix(Numeric.transpose(self.array))
  194.         elif attr == 'H':
  195.             if len(self.array.shape) == 1:
  196.                 self.array.shape = (1, self.array.shape[0])
  197.             
  198.             return Matrix(Numeric.conjugate(Numeric.transpose(self.array)))
  199.         elif attr == 'I':
  200.             return Matrix(LinearAlgebra.inverse(self.array))
  201.         elif attr == 'real':
  202.             return Matrix(self.array.real)
  203.         elif attr == 'imag':
  204.             return Matrix(self.array.imag)
  205.         elif attr == 'flat':
  206.             return Matrix(self.array.flat)
  207.         else:
  208.             raise AttributeError, attr + ' not found.'
  209.  
  210.     
  211.     def __setitem__(self, index, value):
  212.         value = asarray(value, self._typecode)
  213.         self.array[index] = squeeze(value)
  214.  
  215.     
  216.     def __setslice__(self, i, j, value):
  217.         self.array[i:j] = asarray(squeeze(value), self._typecode)
  218.  
  219.     
  220.     def __float__(self):
  221.         return float(squeeze(self.array))
  222.  
  223.     
  224.     def m(self, b):
  225.         return Matrix(self.array * asarray(b))
  226.  
  227.     
  228.     def asarray(self, t = None):
  229.         if t is None:
  230.             return self.array
  231.         else:
  232.             return asarray(self.array, t)
  233.  
  234.  
  235. if __name__ == '__main__':
  236.     from Numeric import *
  237.     m = Matrix([
  238.         [
  239.             1,
  240.             2,
  241.             3],
  242.         [
  243.             11,
  244.             12,
  245.             13],
  246.         [
  247.             21,
  248.             22,
  249.             23]])
  250.     print m * m
  251.     print m.array * m.array
  252.     print transpose(m)
  253.     print m ** -1
  254.     m = Matrix([
  255.         [
  256.             1,
  257.             1],
  258.         [
  259.             1,
  260.             0]])
  261.     print 'Fibonacci numbers:',
  262.     for i in range(10):
  263.         mm = m ** i
  264.         print mm[0][0],
  265.     
  266.     print 
  267.  
  268.